/*
 * Copyright (C) 2013 Sergej Shafarenka, halfbit.de
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file kt in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package dk.dr.radio.diverse;

import android.content.Context;
import android.database.DataSetObserver;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.PointF;
import android.graphics.Rect;
import android.graphics.drawable.GradientDrawable;
import android.graphics.drawable.GradientDrawable.Orientation;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.SoundEffectConstants;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.accessibility.AccessibilityEvent;
import android.widget.AbsListView;
import android.widget.HeaderViewListAdapter;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.SectionIndexer;


/**
 * ListView, which is capable to pin section views at its top while the rest is still scrolled.
 * Kilde: com.hb.views.PinnedSectionListView
 */
public class PinnedSectionListView extends ListView {

  //-- inner classes

  /** List adapter to be implemented for being used with PinnedSectionListView adapter. */
  public static interface PinnedSectionListAdapter extends ListAdapter {
    /** This method shall return 'true' if views of given type has to be pinned. */
    boolean isItemViewTypePinned(int viewType);
  }

  /** Wrapper class for pinned section view and its position in the list. */
  static class PinnedSection {
    public View view;
    public int position;
    public long id;
  }

  //-- class fields

  // fields used for handling touch events
  private final Rect mTouchRect = new Rect();
  private final PointF mTouchPoint = new PointF();
  private int mTouchSlop;
  private View mTouchTarget;
  private MotionEvent mDownEvent;

  // fields used for drawing shadow under a pinned section
  private GradientDrawable mShadowDrawable;
  private int mSectionsDistanceY;
  private int mShadowHeight;

  /** Delegating listener, can be null. */
  OnScrollListener mDelegateOnScrollListener;

  /** Shadow for being recycled, can be null. */
  PinnedSection mRecycleSection;

  /** shadow instance with a pinned view, can be null. */
  PinnedSection mPinnedSection;

  /** Pinned view Y-translation. We use it to stick pinned view to the next section. */
  int mTranslateY;

  /** Scroll listener which does the magic */
  private final OnScrollListener mOnScrollListener = new OnScrollListener() {

    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {
      if (mDelegateOnScrollListener != null) { // delegate
        mDelegateOnScrollListener.onScrollStateChanged(view, scrollState);
      }
    }

    @Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {

      if (mDelegateOnScrollListener != null) { // delegate
        mDelegateOnScrollListener.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount);
      }

      // get expected adapter or fail fast
      ListAdapter adapter = getAdapter();
      if (adapter == null || visibleItemCount == 0) return; // nothing to do

      final boolean isFirstVisibleItemSection =
          isItemViewTypePinned(adapter, adapter.getItemViewType(firstVisibleItem));

      if (isFirstVisibleItemSection) {
        View sectionView = getChildAt(0);
        if (sectionView.getTop() == getPaddingTop()) { // view sticks to the top, no need for pinned shadow
          destroyPinnedShadow();
        } else { // section doesn't stick to the top, make sure we have a pinned shadow
          ensureShadowForFirstItem(firstVisibleItem, firstVisibleItem, visibleItemCount);
        }

      } else { // section is not at the first visible position
        int sectionPosition = findCurrentSectionPosition(firstVisibleItem);
        if (sectionPosition > -1) { // we have section position
          ensureShadowForPosition(sectionPosition, firstVisibleItem, visibleItemCount);
        } else { // there is no section for the first visible item, destroy shadow
          destroyPinnedShadow();
        }
      }
    }
  };

  private Runnable recreatePinnedShadow = new Runnable() {
    @Override
    public void run() {
      recreatePinnedShadow();
    }
  };

  /** Default change observer. */
  private final DataSetObserver mDataSetObserver = new DataSetObserver() {
    @Override
    public void onChanged() {
      post(recreatePinnedShadow);
    }

    ;

    @Override
    public void onInvalidated() {
      post(recreatePinnedShadow);
    }
  };

  //-- constructors

  public PinnedSectionListView(Context context, AttributeSet attrs) {
    super(context, attrs);
    initView();
  }

  public PinnedSectionListView(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    initView();
  }

  private void initView() {
    setOnScrollListener(mOnScrollListener);
    mTouchSlop = ViewConfiguration.get(getContext()).getScaledTouchSlop();
    initShadow(true);
  }

  //-- public API methods

  public void setShadowVisible(boolean visible) {
    initShadow(visible);
    if (mPinnedSection != null) {
      View v = mPinnedSection.view;
      invalidate(v.getLeft(), v.getTop(), v.getRight(), v.getBottom() + mShadowHeight);
    }
  }

  //-- pinned section drawing methods

  public void initShadow(boolean visible) {
    if (visible) {
      if (mShadowDrawable == null) {
        mShadowDrawable = new GradientDrawable(Orientation.TOP_BOTTOM,
            new int[]{Color.parseColor("#ffa0a0a0"), Color.parseColor("#50a0a0a0"), Color.parseColor("#00a0a0a0")});
        mShadowHeight = (int) (8 * getResources().getDisplayMetrics().density);
      }
    } else {
      if (mShadowDrawable != null) {
        mShadowDrawable = null;
        mShadowHeight = 0;
      }
    }
  }

  /** Create shadow wrapper with a pinned view for a view at given position */
  void createPinnedShadow(int position) {

    // try to recycle shadow
    PinnedSection pinnedShadow = mRecycleSection;
    mRecycleSection = null;

    // create new shadow, if needed
    if (pinnedShadow == null) pinnedShadow = new PinnedSection();
    // request new view using recycled view, if such
    View pinnedView = getAdapter().getView(position, pinnedShadow.view, PinnedSectionListView.this);

    // read layout parameters
    LayoutParams layoutParams = (LayoutParams) pinnedView.getLayoutParams();
    if (layoutParams == null) { // create default layout params
      layoutParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
      pinnedView.setLayoutParams(layoutParams);
    }

    int heightMode = MeasureSpec.getMode(layoutParams.height);
    int heightSize = MeasureSpec.getSize(layoutParams.height);

    if (heightMode == MeasureSpec.UNSPECIFIED) heightMode = MeasureSpec.EXACTLY;

    int maxHeight = getHeight() - getListPaddingTop() - getListPaddingBottom();
    if (heightSize > maxHeight) heightSize = maxHeight;

    // measure & layout
    int ws = MeasureSpec.makeMeasureSpec(getWidth() - getListPaddingLeft() - getListPaddingRight(), MeasureSpec.EXACTLY);
    int hs = MeasureSpec.makeMeasureSpec(heightSize, heightMode);
    pinnedView.measure(ws, hs);
    pinnedView.layout(0, 0, pinnedView.getMeasuredWidth(), pinnedView.getMeasuredHeight());
    mTranslateY = 0;

    // initialize pinned shadow
    pinnedShadow.view = pinnedView;
    pinnedShadow.position = position;
    pinnedShadow.id = getAdapter().getItemId(position);

    // store pinned shadow
    mPinnedSection = pinnedShadow;
  }

  /** Destroy shadow wrapper for currently pinned view */
  void destroyPinnedShadow() {
    if (mPinnedSection != null) {
      // keep shadow for being recycled later
      mRecycleSection = mPinnedSection;
      mPinnedSection = null;
    }
  }

  /**
   * Makes sure we have a pinned header for the first position.
   */
  void ensureShadowForFirstItem(int sectionPosition, int firstVisibleItem, int visibleItemCount) {
    // if the first item is a section, only recreate if getTop() < 0

    View sectionView = getChildAt(0);

    // when scrolling downwards, invalidate header iff sectionView's top exceeds view boundaries
    if (mPinnedSection != null && mPinnedSection.position != sectionPosition
        && sectionView.getTop() <= getPaddingTop()) {
      destroyPinnedShadow();
    }
    // when scrolling upwards, invalidate header as soon as sectionView leaves the building
    else if (mPinnedSection != null && mPinnedSection.position == sectionPosition
        && sectionView.getTop() > getPaddingTop()) {
      destroyPinnedShadow();
    }

    // create header based on the view of the current section position
    if (mPinnedSection == null && sectionView.getTop() <= getPaddingTop()) {
      createPinnedShadow(sectionPosition);
    }
    // create header based on the view of the previous section position
    else if (mPinnedSection == null && sectionView.getTop() > getPaddingTop()) {
      int prevSection = findPreviousVisibleSectionPosition(sectionPosition);
      if (prevSection > -1) {
        createPinnedShadow(prevSection);
      }
    }

    if (mPinnedSection != null && sectionView.getTop() > getPaddingTop()) {
      final int bottom = mPinnedSection.view.getBottom() + getPaddingTop();
      mSectionsDistanceY = sectionView.getTop() - bottom;
      if (mSectionsDistanceY < 0) {
        // next section overlaps pinned shadow, move it up
        mTranslateY = mSectionsDistanceY;
      } else {
        // next section does not overlap with pinned, stick to top
        mTranslateY = 0;
      }
    } else {
      mTranslateY = 0;
      mSectionsDistanceY = Integer.MAX_VALUE;
    }

  }

  /** Makes sure we have an actual pinned shadow for given position. */
  void ensureShadowForPosition(int sectionPosition, int firstVisibleItem, int visibleItemCount) {

    if (mPinnedSection != null && mPinnedSection.position != sectionPosition) {
      // invalidate shadow, if required
      destroyPinnedShadow();
    }

    if (mPinnedSection == null) { // create shadow, if empty
      createPinnedShadow(sectionPosition);
    }

    // align shadow according to next section position, if needed
    int nextPosition = sectionPosition + 1;
    if (nextPosition < getCount()) {
      int nextSectionPosition = findFirstVisibleSectionPosition(nextPosition,
          visibleItemCount - (nextPosition - firstVisibleItem));
      if (nextSectionPosition > -1) {
        View nextSectionView = getChildAt(nextSectionPosition - firstVisibleItem);
        final int bottom = mPinnedSection.view.getBottom() + getPaddingTop();
        mSectionsDistanceY = nextSectionView.getTop() - bottom;
        if (mSectionsDistanceY < 0) {
          // next section overlaps pinned shadow, move it up
          mTranslateY = mSectionsDistanceY;
        } else {
          // next section does not overlap with pinned, stick to top
          mTranslateY = 0;
        }
      } else {
        // no other sections are visible, stick to top
        mTranslateY = 0;
        mSectionsDistanceY = Integer.MAX_VALUE;
      }
    }
  }

  int findPreviousVisibleSectionPosition(int fromPosition) {
    ListAdapter adapter = getAdapter();
    for (int childIndex = fromPosition - 1; childIndex >= 0; childIndex--) {
      int viewType = adapter.getItemViewType(childIndex);
      if (isItemViewTypePinned(adapter, viewType))
        return childIndex;
    }
    return -1;
  }

  int findFirstVisibleSectionPosition(int firstVisibleItem, int visibleItemCount) {
    ListAdapter adapter = getAdapter();
    for (int childIndex = 0; childIndex < visibleItemCount; childIndex++) {
      int position = firstVisibleItem + childIndex;
      int viewType = adapter.getItemViewType(position);
      if (isItemViewTypePinned(adapter, viewType)) return position;
    }
    return -1;
  }

  int findCurrentSectionPosition(int fromPosition) {
    ListAdapter adapter = getAdapter();

    if (adapter instanceof SectionIndexer) {
      // try fast way by asking section indexer
      SectionIndexer indexer = (SectionIndexer) adapter;
      int sectionPosition = indexer.getSectionForPosition(fromPosition);
      int itemPosition = indexer.getPositionForSection(sectionPosition);
      int typeView = adapter.getItemViewType(itemPosition);
      if (isItemViewTypePinned(adapter, typeView)) {
        return itemPosition;
      } // else, no luck
    }

    // try slow way by looking through to the next section item above
    for (int position = fromPosition; position >= 0; position--) {
      int viewType = adapter.getItemViewType(position);
      if (isItemViewTypePinned(adapter, viewType)) return position;
    }
    return -1; // no candidate found
  }

  void recreatePinnedShadow() {
    destroyPinnedShadow();
    ListAdapter adapter = getAdapter();
    if (adapter != null && adapter.getCount() > 0) {
      // JACOB: Fix for crash
      int firstVisiblePosition = Math.min(getFirstVisiblePosition(), adapter.getCount() - 1);
      int sectionPosition = findCurrentSectionPosition(firstVisiblePosition);
      if (sectionPosition == -1) return; // no views to pin, exit
      ensureShadowForPosition(sectionPosition,
          firstVisiblePosition, getLastVisiblePosition() - firstVisiblePosition);
    }
  }

  @Override
  public void setOnScrollListener(OnScrollListener listener) {
    if (listener == mOnScrollListener) {
      super.setOnScrollListener(listener);
    } else {
      mDelegateOnScrollListener = listener;
    }
  }

  @Override
  public void onRestoreInstanceState(Parcelable state) {
    super.onRestoreInstanceState(state);
    // restore pinned view after configuration change
    post(recreatePinnedShadow);
  }

  @Override
  public void setAdapter(ListAdapter adapter) {

    // assert adapter in debug mode
    if (adapter != null) {
      if (!(adapter instanceof PinnedSectionListAdapter))
        throw new IllegalArgumentException("Does your adapter implement PinnedSectionListAdapter?");
      if (adapter.getViewTypeCount() < 2)
        throw new IllegalArgumentException("Does your adapter handle at least two types" +
            " of views in getViewTypeCount() method: items and sections?");
    }

    // unregister observer at old adapter and register on new one
    ListAdapter oldAdapter = getAdapter();
    if (oldAdapter != null) oldAdapter.unregisterDataSetObserver(mDataSetObserver);
    if (adapter != null) adapter.registerDataSetObserver(mDataSetObserver);

    // destroy pinned shadow, if new adapter is not same as old one
    if (oldAdapter != adapter) destroyPinnedShadow();

    super.setAdapter(adapter);
  }

  @Override
  protected void onLayout(boolean changed, int l, int t, int r, int b) {
    super.onLayout(changed, l, t, r, b);
    if (mPinnedSection != null) {
      int parentWidth = r - l - getPaddingLeft() - getPaddingRight();
      int shadowWidth = mPinnedSection.view.getWidth();
      if (parentWidth != shadowWidth) {
        recreatePinnedShadow();
      }
    }
  }

  @Override
  protected void dispatchDraw(Canvas canvas) {
    super.dispatchDraw(canvas);

    if (mPinnedSection != null) {

      // prepare variables
      int pLeft = getListPaddingLeft();
      int pTop = getListPaddingTop();
      View view = mPinnedSection.view;

      // draw child
      canvas.save();

      int clipHeight = view.getHeight() +
          (mShadowDrawable == null ? 0 : Math.min(mShadowHeight, mSectionsDistanceY));
      canvas.clipRect(pLeft, pTop, pLeft + view.getWidth(), pTop + clipHeight);

      canvas.translate(pLeft, pTop + mTranslateY);
      drawChild(canvas, mPinnedSection.view, getDrawingTime());

      if (mShadowDrawable != null && mSectionsDistanceY > 0) {
        mShadowDrawable.setBounds(mPinnedSection.view.getLeft(),
            mPinnedSection.view.getBottom(),
            mPinnedSection.view.getRight(),
            mPinnedSection.view.getBottom() + mShadowHeight);
        mShadowDrawable.draw(canvas);
      }

      canvas.restore();
    }
  }

  //-- touch handling methods

  @Override
  public boolean dispatchTouchEvent(MotionEvent ev) {

    final float x = ev.getX();
    final float y = ev.getY();
    final int action = ev.getAction();

    if (action == MotionEvent.ACTION_DOWN
        && mTouchTarget == null
        && mPinnedSection != null
        && isPinnedViewTouched(mPinnedSection.view, x, y)) { // create touch target

      // user touched pinned view
      mTouchTarget = mPinnedSection.view;
      mTouchPoint.x = x;
      mTouchPoint.y = y;

      // copy down event for eventually be used later
      mDownEvent = MotionEvent.obtain(ev);
    }

    if (mTouchTarget != null) {
      if (isPinnedViewTouched(mTouchTarget, x, y)) { // forward event to pinned view
        mTouchTarget.dispatchTouchEvent(ev);
      }

      if (action == MotionEvent.ACTION_UP) { // perform onClick on pinned view
        super.dispatchTouchEvent(ev);
        performPinnedItemClick();
        clearTouchTarget();

      } else if (action == MotionEvent.ACTION_CANCEL) { // cancel
        clearTouchTarget();

      } else if (action == MotionEvent.ACTION_MOVE) {
        if (Math.abs(y - mTouchPoint.y) > mTouchSlop) {

          // cancel sequence on touch target
          MotionEvent event = MotionEvent.obtain(ev);
          event.setAction(MotionEvent.ACTION_CANCEL);
          mTouchTarget.dispatchTouchEvent(event);
          event.recycle();

          // provide correct sequence to super class for further handling
          super.dispatchTouchEvent(mDownEvent);
          super.dispatchTouchEvent(ev);
          clearTouchTarget();

        }
      }

      return true;
    }

    // call super if this was not our pinned view
    return super.dispatchTouchEvent(ev);
  }

  private boolean isPinnedViewTouched(View view, float x, float y) {
    view.getHitRect(mTouchRect);

    // by taping top or bottom padding, the list performs on click on a border item.
    // we don't add top padding here to keep behavior consistent.
    mTouchRect.top += mTranslateY;

    mTouchRect.bottom += mTranslateY + getPaddingTop();
    mTouchRect.left += getPaddingLeft();
    mTouchRect.right -= getPaddingRight();
    return mTouchRect.contains((int) x, (int) y);
  }

  private void clearTouchTarget() {
    mTouchTarget = null;
    if (mDownEvent != null) {
      mDownEvent.recycle();
      mDownEvent = null;
    }
  }

  private boolean performPinnedItemClick() {
    if (mPinnedSection == null) return false;

    OnItemClickListener listener = getOnItemClickListener();
    if (listener != null) {
      View view = mPinnedSection.view;
      playSoundEffect(SoundEffectConstants.CLICK);
      if (view != null) {
        view.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
      }
      listener.onItemClick(this, view, mPinnedSection.position, mPinnedSection.id);
      return true;
    }
    return false;
  }

  public static boolean isItemViewTypePinned(ListAdapter adapter, int viewType) {
    if (adapter instanceof HeaderViewListAdapter) {
      adapter = ((HeaderViewListAdapter) adapter).getWrappedAdapter();
    }
    return ((PinnedSectionListAdapter) adapter).isItemViewTypePinned(viewType);
  }

  /**
   * Sets the selected item and positions the selection y pixels from the top edge of the
   * ListView, or bottom edge of the pinned view iff it exists. (If in touch mode, the item will
   * not be selected but it will still be positioned appropriately.)
   * @param position        Index (starting at 0) of the data item to be selected.
   * @param y               The distance from the top edge of the ListView (plus padding) that the item will be
   *                        positioned.
   * @param adjustForHeader If true, will additionally scroll down so first item will be below header
   */
  public void setSelectionFromTop(final int position, final int y, boolean adjustForHeader) {
    setSelectionFromTop(position, y);

    if (adjustForHeader) {
      post(new Runnable() {
        @Override
        public void run() {
          // do additional scrolling if a pinned view is displayed
          int pinnedOffset = (mPinnedSection == null ? 0 : mPinnedSection.view.getBottom() + getDividerHeight());
          if (pinnedOffset > 0) {
            PinnedSectionListView.super.setSelectionFromTop(position, y + pinnedOffset);
          }
        }
      });
    }
  }

  /**
   * Sets the currently selected item. If in touch mode, the item will not be selected but it will
   * still be positioned appropriately. If the specified selection position is less than 0, then
   * the item at position 0 will be selected.
   * @param position Index (starting at 0) of the data item to be selected.
   */
  @Override
  public void setSelection(int position) {
    setSelectionFromTop(position, 0);
  }
}
